package data.day1213;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @description 邻接矩阵模型类
 */
public class AMWGraph {
    private ArrayList vertexList;//存储点的链表
    private int[][] edges;//邻接矩阵，用来存储边
    private int numOfEdges;//边的数目

    public AMWGraph(int n) {
        //初始化矩阵，一维数组，和边的数目
        edges=new int[n][n];
        vertexList=new ArrayList(n);
        numOfEdges=0;
    }

    //得到结点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回结点i的数据
    public Object getValueByIndex(int i) {
        return vertexList.get(i);
    }

    //返回v1,v2的权值
    public int getWeight(int v1,int v2) {
        return edges[v1][v2];
    }

    //插入结点
    public void insertVertex(Object vertex) {
        vertexList.add(vertexList.size(),vertex);
    }

    //插入结点
    public void insertEdge(int v1,int v2,int weight) {
        edges[v1][v2]=weight;
        numOfEdges++;
    }

    //删除结点
    public void deleteEdge(int v1,int v2) {
        edges[v1][v2]=0;
        numOfEdges--;
    }

    //得到第一个邻接结点的下标
    public int getFirstNeighbor(int index) {
        for(int j=0;j<vertexList.size();j++) {
            if (edges[index][j]>0) {
                return j;
            }
        }
        return -1;
    }

    //根据前一个邻接结点的下标来取得下一个邻接结点
    public int getNextNeighbor(int v1,int v2) {
        for (int j=v2+1;j<vertexList.size();j++) {
            if (edges[v1][j]>0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 搜索顶点的所有相邻顶点
     * @param s
     * @return
     */
    public List<Integer> adj(int s){
        List<Integer> result = new ArrayList<>();
        for(int i=0;i<edges.length;i++){
            if(edges[s][i]==1){
                result.add(i);
            }
        }
        return result;
    }
    public List<Integer> BFS(){
        Queue<Integer> queue = new LinkedList();
        int size = vertexList.size();
        String[] color = new String[size];
        List<Integer> pred = new ArrayList<>();
        Integer[] dist = new Integer[size];
        // 初始化
        for(int i=0;i<size;i++){
            color[i] = "WHITE";
            dist[i] = 0;
        }
        color[0] = "GRAY";
        queue.offer(0); // 把源点添加
        // 广度优先搜索
        while(!queue.isEmpty()){
            int u = queue.poll();
            List<Integer> adj = adj(u); // 搜索顶点u的所有相邻顶点
            for (Integer v : adj) {
                if("WHITE".equals(color[v])){   // 如果是一次发现顶点v
                    color[v] = "GRAY";  // 标记已发现顶点v为待处理状态
                    dist[v] += 1;   // 记录到源点的距离
                    pred.add(u);    // 记录前驱顶点
                    queue.offer(v); // 加入待处理队列
                }
            }
            color[u] = "BLACK"; // 标记当前顶点处理完成
        }
        return pred;
    }

    public static void main(String[] args) {
        int n=8,e=9;//分别代表结点个数和边的数目
        String labels[]={"1","2","3","4","5","6","7","8"};//结点的标识
        AMWGraph graph=new AMWGraph(n);
        for(String label:labels) {
            graph.insertVertex(label);//插入结点
        }
        //插入九条边
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);
        graph.insertEdge(1, 0, 1);
        graph.insertEdge(2, 0, 1);
        graph.insertEdge(3, 1, 1);
        graph.insertEdge(4, 1, 1);
        graph.insertEdge(7, 3, 1);
        graph.insertEdge(7, 4, 1);
        graph.insertEdge(6, 2, 1);
        graph.insertEdge(5, 2, 1);
        graph.insertEdge(6, 5, 1);
        List<Integer> bfs = graph.BFS();
        for (Integer bf : bfs) {
            System.out.println(bf);
        }
    }
}
